home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / exl.cq / exl.c
Encoding:
Text File  |  1985-02-06  |  7.6 KB  |  268 lines
  1. /*
  2.                                  EXL.C
  3.                    Copyright Cheyenne C. Wills 1985
  4.                           All Rights Reserved
  5.  
  6.   Permission is granted to freely distribute this code, but not for
  7. profit, provided that this notice and the following disclaimer are
  8. included in their entirety and without modifications of any sort.  This
  9. work may not be sold, or modified and sold, or included in any other
  10. work to be sold, (except for a nominal media charge), without the
  11. written permission of the author.
  12.  
  13.   Permission is granted to modify the source code and distribute it in
  14. modified form PROVIDED that the authors of any modifications identify
  15. themselves with name and address following this header and that all such
  16. modifications are clearly indicated as to location and purpose, with
  17. descriptive comments that clearly indicate modified lines.
  18.  
  19.   The author would appreciate hearing of any modifications that may be
  20. made, but makes no guarantees that such modifications will be
  21. distributed with future releases of this program.
  22.  
  23. Author's address:
  24.  
  25.         Cheyenne C. Wills
  26.         12 West Locust St.
  27.         Mechanicsburg, Pa. 17055
  28.        (717) 697-5198
  29.  
  30. Disclaimer:
  31.  
  32.   No guarantees or warranties of any kind: This code is distributed
  33. "AS IS" without any warranty of any kind, either expressed or implied,
  34. including, but not limited to the implied warranties of merchantability
  35. and fitness for a particular purpose.  You are soley responsible for the
  36. selection of the program to achieve your intended results and for the
  37. results actually obtained.  Should the program prove defective, you (and
  38. not the author) assume the entire cost of all necessary servicing,
  39. repair, or correction.
  40.  
  41.   Neither the author nor anyone else who has been involved in the
  42. creation, production or delivery of this program shall be liable for any
  43. direct, indirect, consequential or incidental damages arising out of the
  44. use or inability to use this program.
  45.  
  46. */
  47. char *VERSION = "EXL Version 1.0";
  48. char *COPYR = "(c) Copyright Cheyenne Wills 1985";
  49.  
  50. /*
  51.                                History:
  52. Version    Date    Author                 Reason
  53. -------  --------  ------  ---------------------------------------------
  54.  1.0     01/15/85   CCW    Original code.
  55.  
  56. */
  57. /*
  58.  
  59.     exl [-i] cmd file1 [file2...filen] [- parms]
  60.  
  61.     where -i:
  62.         indicates an internal dos command
  63.         such as "DIR" or .BAT files.
  64.  
  65.     where cmd is any valid DOS command
  66.  
  67.     file1 file2...filen are any valid file specs (ex: d:\path\name.ext)
  68.     including wild card characters.
  69.  
  70.     anything following the "-" are considered to be options to be
  71.     appended to the end of the file.
  72.     (note that a space must follow the -)
  73.  
  74.     ex:
  75.     exl -i dir *.lst *.xx - /p
  76.     would generate the commands:
  77.  
  78.     dir *.lst /p
  79.     dir *.xx /p
  80. */
  81.  
  82. #include <stdio.h>
  83. #include <dos.h>
  84. #include <error.h>
  85.  
  86. char internal = 0;
  87. char *cmd;          /* address of command */
  88. char *options = "";      /* address of option string */
  89. char path[FMSIZE];  /* Current path to file */
  90. char cmdstr[127];   /* command string */
  91. int rc;             /* return code */
  92. extern int _oserr;         /* op sys error code */
  93.  
  94. char dta[128];
  95. struct {
  96.     char reserved[21];
  97.     char attrib;
  98.     struct {
  99.         unsigned hh:5;
  100.         unsigned mm:6;
  101.         unsigned ss:5;
  102.     } time;
  103.     struct {
  104.         unsigned yy:7;
  105.         unsigned mm:4;
  106.         unsigned dd:5;
  107.     } date;
  108.     long fsize;
  109.     char filename[13];
  110. } *dtap;
  111.  
  112. main(argc,argv)
  113. int argc;
  114. char **argv;
  115. {
  116.     int i;
  117.     int j;
  118.     char *c;
  119.  
  120.     fprintf(stderr,"%s %s\n",VERSION,COPYR);
  121.  
  122.     dtap = &dta;
  123.  
  124.     if(argc < 3) {
  125.         fputs("EXL Format:\n",stderr);
  126.         fputs("\tEXL [-i] cmd file1 [file2...filen] [- ] [options]\n",stderr);
  127.         fputs("\tWhere: -i indicates command is an internal DOS command\n",stderr);
  128.         fputs("\t\tcmd is the command to execute\n",stderr);
  129.         fputs("\t\tfile1, file2...filen are filespecs to be processed\n",stderr);
  130.         fputs("\t\t\"- \" marks options to follow\n",stderr);
  131.         fputs("\t\toptions will be appended to the command string.\n",stderr);
  132.         exit();
  133.     }
  134.     /* check to see if the first parm is a "-i" */
  135.     if(strcmp(argv[1],"-i") == 0 || strcmp(argv[1],"-I") == 0) {
  136.         i = 2;
  137.         internal++;
  138.     }
  139.     else i = 1;
  140.  
  141.     /* Now locate the command and the options for the command */
  142.     cmd = argv[i++];
  143.     for(j=i;j<argc;j++){
  144.         if(*argv[j] == '-') {
  145.             options = argv[j+1];
  146.             break;
  147.         }
  148.     }
  149.     j--;
  150.  
  151.     for(c=cmd;*c;c++) *c=toupper(*c);
  152.  
  153.     for(;i <= j;i++) docmd(argv[i]);
  154. }
  155.  
  156. /* process one filespec */
  157. docmd(fname)
  158. char *fname;
  159. {
  160.     char *args[3];
  161.     struct fptr {
  162.         struct fptr *next;
  163.         char filen[13];
  164.     } *fbase, *f, *malloc();
  165.  
  166.     if((rc=getfirst(fname))!=NULL) {
  167.         fprintf(stderr,"\nFile Not Found [%s] rc=%d\n",fname,rc);
  168.         askcont();
  169.         return;
  170.     }
  171.     fbase = malloc(sizeof(struct fptr));
  172.     f=fbase;
  173.     f->next = NULL;
  174.     strcpy(f->filen,dtap->filename);
  175.  
  176.     while( getnext() == NULL) {
  177.         f->next = malloc(sizeof(struct fptr));
  178.         f=f->next;
  179.         f->next = NULL;
  180.         strcpy(f->filen,dtap->filename);
  181.     }
  182.     for(f=fbase;f!=NULL;f=f->next) {
  183.  
  184.         if(internal) {
  185.             strcpy(cmdstr,cmd);
  186.             strcat(cmdstr," ");
  187.         }
  188.         else {
  189.             cmdstr[0] = '\0';
  190.             args[0] = cmd;
  191.             args[1] = cmdstr;
  192.             args[2] = NULL;
  193.         }
  194.         strcat(cmdstr,path);
  195.         strcat(cmdstr,f->filen);
  196.         strcat(cmdstr," ");
  197.         strcat(cmdstr,options);
  198.         if(internal) {
  199.             printf("=>%s\n",cmdstr);
  200.             rc=system(cmdstr);
  201.         }
  202.         else {
  203.             printf("=>%s %s\n",cmd,cmdstr);
  204.             rc=forkvp(cmd,&args);
  205.         }
  206.         if(rc!=0) {
  207.             if(_oserr)
  208.                 fprintf(stderr,"\nUnable to invoke [%s] RC=%d\n",cmd,_oserr);
  209.             else
  210.                 fprintf(stderr,"\nInvalid parm to [%s] parm=[%s]\n",cmd,cmdstr);
  211.             askcont();
  212.             goto Retstor;
  213.         }
  214.  
  215.         rc=wait();
  216.         if(rc) {
  217.             fprintf(stderr,"\n%s RC=%d\n",cmd,rc);
  218.             askcont();
  219.         }
  220.     }
  221. Retstor:
  222.     do { f=fbase->next; free(fbase); fbase=f; } while(f!=NULL);
  223. }
  224.  
  225. getfirst(name)
  226. char *name;
  227. {
  228.     int i;
  229.     union REGS inregs,outregs;
  230.  
  231.     /* First set the address of the current DTA */
  232.     bdos(0x1a,&dta);
  233.  
  234.     /* Parse out the path portion of the filename */
  235.     for(i=strlen(name);
  236.         i >= 0 && name[i]!='/' &&  name[i]!=':' && name[i]!='\\';
  237.         i--);
  238.     /* i now should contain the length of the path */
  239.     if(i>0)     stccpy(&path,name,i+2);
  240.     else path[0]='\0';
  241.     inregs.h.ah = 0x4e;
  242.     inregs.x.dx = (int)name;
  243.     inregs.x.cx = 0x01 | 0x02 | 0x04 | 0x20;
  244.     if(intdos(&inregs,&outregs) & 0x0001) return outregs.x.ax;
  245.     else return NULL;
  246. }
  247. getnext()
  248. {
  249.     int r;
  250.     union REGS inregs,outregs;
  251.     inregs.h.ah = 0x4f;
  252.     inregs.x.dx = (int)&dta;
  253.  
  254.     if(intdos(&inregs,&outregs) & 0x0001) return outregs.x.ax;
  255.     else return NULL;
  256. }
  257. askcont()
  258. {
  259.     int c;
  260.  
  261.     fputs("\n**Error, do you want to continue? (y/n)",stderr);
  262.     while( tolower(c=getch())!='y' &&
  263.            tolower(c) != 'n'  );
  264.     putch(c);
  265.     if(c=='y') return;
  266.     exit(rc);
  267. }
  268.